
/*
    Software License

    Copyright (C) 2021-05-24  Xoronos

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

/*
    Liabilities

    The software is provided "AS IS" without any warranty of any kind, either expressed,
    implied, or statutory, including, but not limited to, any warranty that the software
    will conform to specifications, any implied warranties of merchantability, fitness
    for a particular purpose, and freedom from infringement, and any warranty that the
    documentation will conform to the software, or any warranty that the software will
    be error free.

    In no event shall Xoronos be liable for any damages, including, but not limited to,
    direct, indirect, special or consequential damages, arising out of, resulting from,
    or in any way connected with this software, whether or not based upon warranty,
    contract, tort, or otherwise, whether or not injury was sustained by persons or
    property or otherwise, and whether or not loss was sustained from, or arose out of
    the results of, or use of, the software or services provided hereunder.

    To request the provided software under a different license you can contact us at
    support@xoronos.com
*/

#include "lexscript.h"
#include "lexscript_backend.h"

void lex_script_decode_encode( int rnd, char *all_args[]
 )
{

    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    lex_print_scripts_copy_plain_text(  );

    force_perm = 0;
    arch = 128;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#\n",
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XDE_DECODE_ENCODE][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to first encode and then decode a plain text file\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nencode the input plain text with the generated encoding parameters\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_example_decode_encode( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ndecode the encoded file to re-generate the plain text file\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 4;
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_example_decode_encode( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_mine_xmatrix_comp( int rnd, int rnd_ot, char *all_args[]
 )
{

    int arch, force_perm;
    int neutral_standard_alice_bob;
    int neutral_personality;
    int force_pseudo_random;

    time_t t;
    int rand_var;

    force_perm = 0;
    force_pseudo_random = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_pseudo_random = 0;
        } else {
            force_pseudo_random = 1;
        }

    }

    rnd = 0;

    if ( rnd_ot == 0 ) {
        if ( force_pseudo_random == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
                      "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
                      &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMP_MAKE_POINT][2],
                      &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
                      &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2], &all_args[XCXC_CHECK_XMATRIX_COMP][2],
                      &all_args[XCX_CHECK_XMATRIX][2], &all_args[XPXCR_PERMUTE_XMATRIX_COMP_RANDOM][2],
                      &all_args[XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC][2],
                      &all_args[XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL][2] );
        } else {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
                      "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
                      &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
                      &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
                      &all_args[XCXC_CHECK_XMATRIX_COMP][2], &all_args[XCX_CHECK_XMATRIX][2],
                      &all_args[XPXCR_PERMUTE_XMATRIX_COMP_RANDOM][2],
                      &all_args[XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC][2],
                      &all_args[XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL][2] );
        }

    } else {
        if ( force_pseudo_random == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
                      "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
                      &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMP_MAKE_POINT][2],
                      &all_args[XMXCO_MINE_XMATRIX_COMP_OT][2], &all_args[XCXC_CHECK_XMATRIX_COMP][2],
                      &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
                      &all_args[XCX_CHECK_XMATRIX][2], &all_args[XPXCR_PERMUTE_XMATRIX_COMP_RANDOM][2],
                      &all_args[XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC][2],
                      &all_args[XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL][2] );
        } else {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
                      "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
                      &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMXCO_MINE_XMATRIX_COMP_OT][2],
                      &all_args[XCXC_CHECK_XMATRIX_COMP][2], &all_args[XCX_CHECK_XMATRIX][2],
                      &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
                      &all_args[XPXCR_PERMUTE_XMATRIX_COMP_RANDOM][2],
                      &all_args[XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC][2],
                      &all_args[XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL][2] );
        }

    }

    XLEX_PRINT(  );

    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );

    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    neutral_standard_alice_bob = 1;

    if ( force_pseudo_random == 1 ) {

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
                  "printf '\\ngenerate a seed point to mine a xoron matrix compressed data-structure in a deterministic way\\n'\n" );
        XLEX_PRINT(  );
        lex_print_scripts_command_prelude( XMP_MAKE_POINT, all_args );
        lex_example_make_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
        XLEX_PRINT(  );

    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    if ( rnd_ot == 0 ) {
        lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
        lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, force_pseudo_random,
                                            neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
        XLEX_PRINT(  );
    } else {
        lex_print_scripts_command_prelude( XMXCO_MINE_XMATRIX_COMP_OT, all_args );
        lex_example_mine_xmatrix_comp_ot( rnd, arch, force_perm, force_pseudo_random,
                                          neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck generated xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCXC_CHECK_XMATRIX_COMP, all_args );
    lex_example_check_xmatrix_comp( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck decompressed xoron matrix\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCX_CHECK_XMATRIX, all_args );
    lex_example_check_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nchanging the xoron matrix compressed randomly\\n'\n" );
    XLEX_PRINT(  );
    neutral_personality = 1;
    lex_print_scripts_command_prelude( XPXCR_PERMUTE_XMATRIX_COMP_RANDOM, all_args );
    lex_example_permute_xmatrix_comp_random( rnd, arch, force_perm, neutral_standard_alice_bob,
                                             neutral_personality, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nchanging the xoron matrix compressed pseudo-randomly\\n'\n" );
    XLEX_PRINT(  );
    neutral_personality = 1;
    lex_print_scripts_command_prelude( XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC, all_args );
    lex_example_permute_xmatrix_comp_deterministic( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                    neutral_personality, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nchanging the xoron matrix compressed with a key\\n'\n" );
    XLEX_PRINT(  );
    neutral_personality = 1;
    lex_print_scripts_command_prelude( XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL, all_args );
    lex_example_permute_xmatrix_comp_confidential( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                   neutral_personality, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_make_confidential_pseudo_random_number( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMP_MAKE_POINT][2],
              &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nmake a monomial key to use in the confidential pseudo random number generator\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate the starting point\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XMP_MAKE_POINT, all_args );
    lex_example_make_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate the next point\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER, all_args );
    lex_example_make_confidential_pseudo_random_number( rnd, arch, force_perm,
                                                        neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_monomial_key_exchange( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XMSP_MAKE_START_POINT][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XCBKTSP_CONVERT_BINOMIAL_KEY_TO_START_POINT][2],
              &all_args[XEMK_EXCHANGE_MONOMIAL_KEY][2], &all_args[XMBK_MAKE_BINOMIAL_KEY][2],
              &all_args[XDE_DECODE_ENCODE][2], &all_args[XDEP_DUMP_ENCODING_PARAM][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate encoding parameters for Alice\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate encoding parameters for Bob\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 3;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate generic encoding parameters\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nencode the xoron matrix compressed for Alice\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sxmatrix_comp.xf %s %salice_xmatrix_comp.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nencode the xoron matrix for Bob\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_xmatrix.xf %s %sbob_xmatrix.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice generates start point\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice generates monomial key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice generates binomial key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nencode binomial key for Bob\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %salice_binomial_key.xf %s %salice_binomial_key_for_bob.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nconvert binomial key to start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_original_command(  );
    neutral_standard_alice_bob = 3;
    lex_example_convert_binomial_key_to_start_point( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                     all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nBob generates monomial key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 3;
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nBob generates binomial key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 3;
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecode binomial key for Bob\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_encoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %sbob_binomial_key.xf %s %sbob_binomial_key_for_alice.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice generates the shared monomial key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_exchange_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_polyvalent_key_exchange( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XPH_PRINT_HEADER][2],
              &all_args[XMMK_MAKE_MONOVALENT_KEY][2], &all_args[XCMK_CHECK_MONOVALENT_KEY][2],
              &all_args[XEPK_EXCHANGE_POLYVALENT_KEY][2], &all_args[XDE_DECODE_ENCODE][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate encoding parameters for Alice\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate encoding parameters for Bob\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 3;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate generic encoding parameters\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nencode the xoron matrix compressed for Alice\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sxmatrix_comp.xf %s %salice_xmatrix_comp.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nencode xoron matrix for Bob\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_xmatrix.xf %s %sbob_xmatrix.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice generates monovalent key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOVALENT_KEY, all_args );
    lex_example_make_monovalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nencode monovalent key for Bob\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDE_DECODE_ENCODE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %salice_monovalent_key.xf %s %salice_monovalent_key_for_bob.xf \n",
              all_args[XDE_DECODE_ENCODE], all_args[XDE_TO_DECODE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDE_TO_ENCODE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nBob prints Alice monovalent key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 3;
    lex_print_scripts_command_prelude( XPH_PRINT_HEADER, all_args );
    lex_example_print_header( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "start_timestamp=$(cat %sbob_info_log.json | grep start_timestamp | sed 's/^.*:.// ; s/.$//')\n",
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "end_timestamp=$(cat %sbob_info_log.json | grep end_timestamp | sed 's/^.*:.// ; s/.$//')\n",
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "bob_architecture=$(cat %sbob_info_log.json | grep nbits | sed 's/^.*:.// ; s/.$//')\n",
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "bob_permutation_used=$(cat %sbob_info_log.json | grep permutation_used | sed 's/^.*:.//')\n",
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "if [ $bob_permutation_used == 1 ] ; then\n    bob_permutation_str=''\nelse\n    bob_permutation_str=' -no-permutation-key '\nfi\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nBob generates the monovalent key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOVALENT_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_encoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %salice_encoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbob_xmatrix.xf ", all_args[XSC_SEQUENCE_CONF],
              all_args[XSC_XMATRIX], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s $bob_architecture $bob_permutation_str ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %sbob_monovalent_key.xf %s %sbob_polyvalent_key.xf %s %sbob_polyvalent_proof.xf %s $start_timestamp %s $end_timestamp \n",
              all_args[XMMK_MAKE_MONOVALENT_KEY], all_args[XMMK_MONOVALENT_KEY], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XMMK_POLYVALENT_KEY], LEXER_EXAMPLES_DUMP_DIR, all_args[XMMK_POLYVALENT_PROOF],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XMMK_START_TIMESTAMP], all_args[XMMK_END_TIMESTAMP] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice generates shared polyvalent key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XEPK_EXCHANGE_POLYVALENT_KEY, all_args );
    lex_example_exchange_polyvalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nAlice checks Bob monovalent key\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 2;
    lex_print_scripts_command_prelude( XCMK_CHECK_MONOVALENT_KEY, all_args );
    lex_example_check_monovalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );
}

void lex_script_zkp_binomial_key( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XMMK_MAKE_MONOMIAL_KEY][2], &all_args[XMBK_MAKE_BINOMIAL_KEY][2],
              &all_args[XMSP_MAKE_START_POINT][2], &all_args[XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY][2],
              &all_args[XMR_MAKE_RESPONSE][2], &all_args[XMMP_MAKE_MONOMIAL_PROOF][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XCMP_CHECK_MONOMIAL_PROOF][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate monomial and binomial commitment\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY, all_args );
    lex_example_make_commitment_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial response\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMR_MAKE_RESPONSE, all_args );
    lex_example_make_response( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial proof\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMP_MAKE_MONOMIAL_PROOF, all_args );
    lex_example_make_monomial_proof( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck monomial proof\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCMP_CHECK_MONOMIAL_PROOF, all_args );
    lex_example_check_monovalent_proof( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_zkp_signature( int rnd, char *all_args[]
 )
{

    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    lex_print_scripts_copy_plain_text(  );

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XMSP_MAKE_START_POINT][2], &all_args[XMBK_MAKE_BINOMIAL_KEY][2],
              &all_args[XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XMR_MAKE_RESPONSE][2], &all_args[XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMSS_MAKE_SIGNATURE_SYMMETRIC][2],
              &all_args[XCMPSS_CHECK_MONOMIAL_PROOF_SYM_SIGNATURE][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerates binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate symmetric signature\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSS_MAKE_SIGNATURE_SYMMETRIC, all_args );
    lex_example_make_signature_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate monomial and binomial commitment\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE, all_args );
    lex_example_make_commitment_sym_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial response\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMR_MAKE_RESPONSE, all_args );
    lex_example_make_response( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial proof\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE, all_args );
    lex_example_make_monomial_proof_sym_signature( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                   all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck monomial proof\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCMP_CHECK_MONOMIAL_PROOF, all_args );
    lex_example_check_monovalent_proof_sym_signature( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                      all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_zkp_certificate( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE][2],
              &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XMMK_MAKE_MONOVALENT_KEY][2],
              &all_args[XMR_MAKE_RESPONSE][2], &all_args[XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMCS_MAKE_CERTIFICATE_SYMMETRIC][2],
              &all_args[XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmake monovalent key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOVALENT_KEY, all_args );
    lex_example_make_monovalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate symmetric certificate\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCS_MAKE_CERTIFICATE_SYMMETRIC, all_args );
    lex_example_make_certificate_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate monomial and binomial commitment\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE, all_args );
    lex_example_make_commitment_sym_certificate( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                 all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial response\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMR_MAKE_RESPONSE, all_args );
    lex_example_make_response( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial proof\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE, all_args );
    lex_example_make_monomial_proof_sym_certificate( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                     all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck monomial proof\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE, all_args );
    lex_example_check_monovalent_proof_sym_certificate( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                        all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_sym_signature( int rnd, char *all_args[]
 )
{

    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    lex_print_scripts_copy_plain_text(  );

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XMSS_MAKE_SIGNATURE_SYMMETRIC][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XCSS_CHECK_SIGNATURE_SYMMETRIC][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate symmetric signature\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE, all_args );
    lex_example_make_signature_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck symmetric signature \\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE, all_args );
    lex_example_check_signature_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_asy_signature( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    lex_print_scripts_copy_plain_text(  );

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XMBK_MAKE_BINOMIAL_KEY][2], &all_args[XMSP_MAKE_START_POINT][2],
              &all_args[XMSA_MAKE_SIGNATURE_ASYMMETRIC][2], &all_args[XCSA_CHECK_SIGNATURE_ASYMMETRIC][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate signature asymmetric\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSA_MAKE_SIGNATURE_ASYMMETRIC, all_args );
    lex_example_make_signature_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck signature asymmetric\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCSA_CHECK_SIGNATURE_ASYMMETRIC, all_args );
    lex_example_check_signature_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_sym_certificate( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2],
              &all_args[XMCS_MAKE_CERTIFICATE_SYMMETRIC][2],
              &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XMMK_MAKE_MONOVALENT_KEY][2],
              &all_args[XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY][2],
              &all_args[XCCS_CHECK_CERTIFICATE_SYMMETRIC][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmake monovalent key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOVALENT_KEY, all_args );
    lex_example_make_monovalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate symmetric certificate\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE, all_args );
    lex_example_make_certificate_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck symmetric certificate\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCCS_CHECK_CERTIFICATE_SYMMETRIC, all_args );
    lex_example_check_certificate_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nextract monovalent key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %ssymmetric_certificate.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_SYM_CERTIFICATE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %sextracted_monovalent_key.xf \n",
              all_args[XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY],
              all_args[XCSCTMK_MONOVALENT_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_asy_certificate( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XMCA_MAKE_CERTIFICATE_ASYMMETRIC][2],
              &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2],
              &all_args[XMSP_MAKE_START_POINT][2],
              &all_args[XMBK_MAKE_BINOMIAL_KEY][2],
              &all_args[XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY][2],
              &all_args[XCCA_CHECK_CERTIFICATE_ASYMMETRIC][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmake start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmake binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nsubject generates the monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %ssubject_monomial_key.xf ",
              all_args[XMMK_MAKE_MONOMIAL_KEY], all_args[XMMK_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nsubject generates the binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sstart_point.xf %s %ssubject_monomial_key.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_START_POINT], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XAC_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sxmatrix.xf ", all_args[XSC_SEQUENCE_CONF],
              all_args[XSC_XMATRIX], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %ssubject_binomial_key.xf ",
              all_args[XMBK_MAKE_BINOMIAL_KEY], all_args[XMBK_BINOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate asymmetric certificate\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMCA_MAKE_CERTIFICATE_ASYMMETRIC, all_args );
    lex_example_make_certificate_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck asymmetric certificate\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCCA_CHECK_CERTIFICATE_ASYMMETRIC, all_args );
    lex_example_check_certificate_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nextract monovalent key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY, all_args );
    lex_example_convert_asymmetric_certificate_to_binomial_key( rnd, arch, force_perm,
                                                                neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_hash( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2],
              &all_args[XMH_MAKE_HASH][2], &all_args[XCH_CHECK_HASH][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate hash\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMH_MAKE_HASH, all_args );
    lex_example_make_hash( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck hash\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCH_CHECK_HASH, all_args );
    lex_example_check_hash( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_checksum( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#\n",
              &all_args[XMC_MAKE_CHECKSUM][2], &all_args[XCC_CHECK_CHECKSUM][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    neutral_standard_alice_bob = 1;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate checksums\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMC_MAKE_CHECKSUM, all_args );
    lex_example_make_checksum( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck checksums\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCC_CHECK_CHECKSUM, all_args );
    lex_example_check_checksum( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_split( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XSS_SPLIT_SYMMETRIC][2],
              &all_args[XJS_JOIN_SYMMETRIC][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nsplit file\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XSS_SPLIT_SYMMETRIC, all_args );
    lex_example_split_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\njoin files\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XJS_JOIN_SYMMETRIC, all_args );
    lex_example_join_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_encrypt_symmetric( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XES_ENCRYPT_SYMMETRIC][2],
              &all_args[XDS_DECIPHER_SYMMETRIC][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nencrypt file\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XES_ENCRYPT_SYMMETRIC, all_args );
    lex_example_encrypt_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecrypt file\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDS_DECIPHER_SYMMETRIC, all_args );
    lex_example_decipher_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_encrypt_asymmetric( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XEA_ENCRYPT_ASYMMETRIC][2],
              &all_args[XMSP_MAKE_START_POINT][2], &all_args[XMBK_MAKE_BINOMIAL_KEY][2],
              &all_args[XDA_DECIPHER_ASYMMETRIC][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nencrypt file\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XEA_ENCRYPT_ASYMMETRIC, all_args );
    lex_example_encrypt_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecrypt file\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDA_DECIPHER_ASYMMETRIC, all_args );
    lex_example_decipher_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_conversions( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMH_MAKE_HASH][2],
              &all_args[XMSP_MAKE_START_POINT][2], &all_args[XMBK_MAKE_BINOMIAL_KEY][2],
              &all_args[XCHTP_CONVERT_HASH_TO_POINT][2],
              &all_args[XCSPTP_CONVERT_START_POINT_TO_POINT][2],
              &all_args[XCPTSP_CONVERT_POINT_TO_START_POINT][2],
              &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT][2],
              &all_args[XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT][2],
              &all_args[XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY][2],
              &all_args[XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY][2],
              &all_args[XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY][2],
              &all_args[XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE][2],
              &all_args[XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE][2]
         );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate a binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmake hash\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMH_MAKE_HASH, all_args );
    lex_example_make_hash( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nconvert start point to point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCSPTP_CONVERT_START_POINT_TO_POINT, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sstart_point.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_START_POINT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %spoint_converted.xf \n\n",
              all_args[XCSPTP_CONVERT_START_POINT_TO_POINT], all_args[XCSPTP_POINT],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nconvert point to start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCPTSP_CONVERT_POINT_TO_START_POINT, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %spoint_converted.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_POINT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sstart_point_converted.xf \n\n",
              all_args[XCPTSP_CONVERT_POINT_TO_START_POINT], all_args[XCPTSP_START_POINT],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nconvert point to monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %spoint_converted.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_POINT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %smonomial_key_converted.xf \n\n",
              all_args[XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY], all_args[XCPTMK_MONOMIAL_KEY],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nconvert monomial key to point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %smonomial_key_converted.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %spoint_reconverted.xf \n\n",
              all_args[XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT], all_args[XCMKTP_POINT],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nconvert monomial key to monomial commitment\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %smonomial_key_converted.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %smonomial_commitment_converted.xf \n\n",
              all_args[XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT],
              all_args[XCMKTMC_MONOMIAL_COMMITMENT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nconvert monomial commitment to monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %smonomial_commitment_converted.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_MONOMIAL_COMMITMENT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %smonomial_key_reconverted.xf \n\n",
              all_args[XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY], all_args[XCMCTMK_MONOMIAL_KEY],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nconvert hash to point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCHTP_CONVERT_HASH_TO_POINT, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %shash.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_HASH], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %spoint_rereconverted.xf \n\n",
              all_args[XCHTP_CONVERT_HASH_TO_POINT], all_args[XCHTP_POINT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nconvert binomial key to asymmetric signature\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbinomial_key.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_BINOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sasymmetric_signature.xf \n\n",
              all_args[XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE],
              all_args[XCBKTAS_ASYMMETRIC_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nconvert asymmetric signature to binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sasymmetric_signature.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_ASY_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sreconstructed_binomial_key.xf \n\n",
              all_args[XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY], all_args[XCASTBK_BINOMIAL_KEY],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nconvert binomial key to symmetric signature\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sbinomial_key.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_BINOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %ssymmetric_signature.xf \n\n",
              all_args[XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE],
              all_args[XCBKTSS_SYMMETRIC_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nconvert symmetric signature to binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %ssymmetric_signature.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_SYM_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %srereconstructed_binomial_key.xf \n\n",
              all_args[XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY], all_args[XCSSTBK_BINOMIAL_KEY],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_make_block( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;
    neutral_standard_alice_bob = 1;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XMB_MAKE_BLOCK][2], &all_args[XSHFB_STRIP_HEADER_FROM_BLOCK][2],
              &all_args[XCCB_CHECK_COMPLETE_BLOCK][2], &all_args[XCB_COMBINE_BLOCKS][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncreate the first block\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMB_MAKE_BLOCK, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s 0 %s 100000 %s 35 %s %sblock_0.xf %s %splain_text.txt \n\n", all_args[XMB_MAKE_BLOCK],
              all_args[XMB_OFFSET], all_args[XMB_LENGTH], all_args[XMB_TAG], all_args[XMB_BLOCK_FILE],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XMB_PLAIN_TEXT], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncreate the second block\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMB_MAKE_BLOCK, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s 100000 %s 201097 %s 35 %s %sblock_1.xf %s %splain_text.txt \n\n",
              all_args[XMB_MAKE_BLOCK], all_args[XMB_OFFSET], all_args[XMB_LENGTH], all_args[XMB_TAG],
              all_args[XMB_BLOCK_FILE], LEXER_EXAMPLES_DUMP_DIR, all_args[XMB_PLAIN_TEXT],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmerge the two blocks\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCB_COMBINE_BLOCKS, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sblock_0.xf %s %sblock_1.xf %s %sblock_file.xf \n\n",
              all_args[XCB_COMBINE_BLOCKS], all_args[XCB_BLOCK_FILE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XCB_BLOCK_FILE], LEXER_EXAMPLES_DUMP_DIR, all_args[XCB_COMBINED_BLOCK_FILE],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck if the block is complete\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCCB_CHECK_COMPLETE_BLOCK, all_args );
    lex_example_check_complete_blocks( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nstrip the block header\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XSHFB_STRIP_HEADER_FROM_BLOCK, all_args );
    lex_example_strip_header_from_block( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_print_lib_info( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;
    neutral_standard_alice_bob = 1;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#\n",
              &all_args[XPLI_PRINT_LIB_INFO][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nprint library info\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XPLI_PRINT_LIB_INFO, all_args );
    lex_example_print_lib_info( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_print_header( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var;

    force_perm = 0;
    arch = 256;

    lex_print_scripts_copy_plain_text(  );

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;
    neutral_standard_alice_bob = 1;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XMP_MAKE_POINT][2], &all_args[XPH_PRINT_HEADER][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmake point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMP_MAKE_POINT, all_args );
    lex_example_make_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nprint header\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XPH_PRINT_HEADER, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sinfo_log.json ",
              all_args[XLC_LOGGING_CONF], all_args[XLC_LIB_INFO_LOG], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %spoint.xf \n\n",
              all_args[XPH_PRINT_HEADER], all_args[XPH_XRN_FILE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_ring_signature( int rnd, char *all_args[]
 )
{
    int arch, force_perm;
    int neutral_standard_alice_bob;

    time_t t;
    int rand_var, i;

    lex_print_scripts_copy_plain_text(  );

    force_perm = 0;
    arch = 256;

    if ( rnd == 1 ) {
        srand( ( unsigned ) time( &t ) );
        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            arch = 128;
        } else {
            arch = 256;
        }

        rand_var = rand(  );
        if ( rand_var % 2 == 0 ) {
            force_perm = 0;
        } else {
            force_perm = 1;
        }

    }

    rnd = 0;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XDX_DECOMPRESS_XMATRIX][2], &all_args[XMXCR_MINE_XMATRIX_COMP_RND][2],
              &all_args[XDEP_DUMP_ENCODING_PARAM][2], &all_args[XMMK_MAKE_MONOMIAL_KEY][2],
              &all_args[XMBK_MAKE_BINOMIAL_KEY][2], &all_args[XMSP_MAKE_START_POINT][2],
              &all_args[XMRS_MAKE_RING_SIGNATURE][2], &all_args[XCRS_CHECK_RING_SIGNATURE][2],
              &all_args[XPRS_PERMUTE_RING_SIGNATURE][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\ngenerate encoding parameters to encode all the xoron data structures\\n'\n" );
    XLEX_PRINT(  );
    neutral_standard_alice_bob = 1;
    lex_print_scripts_command_prelude( XDEP_DUMP_ENCODING_PARAM, all_args );
    lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nmining the xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMXCR_MINE_XMATRIX_COMP_RND, all_args );
    lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, 0, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecompress xoron matrix compressed\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XDX_DECOMPRESS_XMATRIX, all_args );
    lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate start point\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSP_MAKE_START_POINT, all_args );
    lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nverifier generates the monomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    if ( force_perm == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
                  all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
                  all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    }

    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sverifier_monomial_key.xf ",
              all_args[XMMK_MAKE_MONOMIAL_KEY], all_args[XMMK_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nverifier generates the binomial key\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sstart_point.xf %s %sverifier_monomial_key.xf ",
              all_args[XAC_ARITHMETIC_CONF], all_args[XAC_START_POINT], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XAC_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sxmatrix.xf ", all_args[XSC_SEQUENCE_CONF],
              all_args[XSC_XMATRIX], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sverifier_binomial_key.xf ",
              all_args[XMBK_MAKE_BINOMIAL_KEY], all_args[XMBK_BINOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    for ( i = 0; i < 3; i++ ) {

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecoy generates the monomial key\\n'\n" );
        XLEX_PRINT(  );
        lex_print_scripts_command_prelude( XMMK_MAKE_MONOMIAL_KEY, all_args );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
                  all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
                  all_args[XDC_NO_PASSWORD] );
        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        if ( force_perm == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
                      all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
        } else {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d  ",
                      all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
        }

        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sdecoy_monomial_key_%d.xf ",
                  all_args[XMMK_MAKE_MONOMIAL_KEY], all_args[XMMK_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR, i );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ndecoy generates the binomial key\\n'\n" );
        XLEX_PRINT(  );
        lex_print_scripts_command_prelude( XMBK_MAKE_BINOMIAL_KEY, all_args );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
                  all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
                  all_args[XDC_NO_PASSWORD] );
        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
                  all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
                  all_args[XDC_NO_PASSWORD] );
        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sstart_point.xf %s %sdecoy_monomial_key_%d.xf ",
                  all_args[XAC_ARITHMETIC_CONF], all_args[XAC_START_POINT], LEXER_EXAMPLES_DUMP_DIR,
                  all_args[XAC_MONOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR, i );
        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sxmatrix.xf ", all_args[XSC_SEQUENCE_CONF],
                  all_args[XSC_XMATRIX], LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
                  all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
        XLEX_PRINT(  );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sdecoy_binomial_key_%d.xf ",
                  all_args[XMBK_MAKE_BINOMIAL_KEY], all_args[XMBK_BINOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR, i );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
        XLEX_PRINT(  );

    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ngenerate ring signature \\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMRS_MAKE_RING_SIGNATURE, all_args );
    lex_example_make_ring_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "mv %sring_signature.xf %sring_signature_0.xf\n\n",
              LEXER_EXAMPLES_DUMP_DIR, LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nregenerate a ring signature to emulate a received one\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMRS_MAKE_RING_SIGNATURE, all_args );
    lex_example_make_ring_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "mv %sring_signature.xf %sring_signature_1.xf\n\n",
              LEXER_EXAMPLES_DUMP_DIR, LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nsigner permutes the (received) ring signature\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XPRS_PERMUTE_RING_SIGNATURE, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %sencoding_param.xf %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_ENCODING_PARAM], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %d ",
              all_args[XPC_PERMUTATION_CONF], all_args[XPC_ARCH], arch );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %sbinomial_key.xf %s %sverifier_binomial_key.xf %s %sring_signature_0.xf %s %sring_signature_1.xf %s %sring_signature.xf",
              all_args[XPRS_PERMUTE_RING_SIGNATURE], all_args[XPRS_SIGNER_BINOMIAL_KEY],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XPRS_VERIFIER_BINOMIAL_KEY], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XPRS_SIGNER_RING_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XPRS_VERIFIER_RING_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XPRS_PERMUTED_RING_SIGNATURE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncheck ring signature \\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XCRS_CHECK_RING_SIGNATURE, all_args );
    lex_example_check_ring_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_make_steganography_raw( int rnd, char *all_args[]
 )
{
    int neutral_standard_alice_bob;

    lex_print_scripts_copy_plain_text(  );

    neutral_standard_alice_bob = 1;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#\n",
              &all_args[XMSR_MAKE_STEGANOGRAPHY_RAW][2], &all_args[XESR_EXTRACT_STEGANOGRAPHY_RAW][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncreate a random envelop file\\n'\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "head -c 32M /dev/urandom > " );
    XLEX_PRINT(  );
    lex_print_path_option( XGC_ENVELOP_FILE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncreate steganography raw file\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSR_MAKE_STEGANOGRAPHY_RAW, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s  %s %ssteganography_raw.xf %s %senvelop_file.xf %s %splain_text.txt \n\n",
              all_args[XMSR_MAKE_STEGANOGRAPHY_RAW],
              all_args[XMSR_EMBEDDED_FILE],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XMSR_ENVELOP_FILE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XMSR_SOURCE_FILE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nextract steganography raw\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XESR_EXTRACT_STEGANOGRAPHY_RAW, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %ssteganography_raw.xf %s %sraw_file.xf \n\n",
              all_args[XESR_EXTRACT_STEGANOGRAPHY_RAW], all_args[XESR_EMBEDDED_FILE],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XESR_RAW_FILE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lex_script_make_steganography_block( int rnd, char *all_args[]
 )
{
    int neutral_standard_alice_bob;

    lex_print_scripts_copy_plain_text(  );

    neutral_standard_alice_bob = 1;

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\n# the list of commands used in this script:\n#\n#    %s\n#    %s\n#    %s\n#\n",
              &all_args[XMSB_MAKE_STEGANOGRAPHY_BLOCK][2], &all_args[XGC_GET_CAPACITY][2],
              &all_args[XESB_EXTRACT_STEGANOGRAPHY_BLOCK][2] );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude_comments(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncreate a random envelop file\\n'\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "head -c 32M /dev/urandom > " );
    XLEX_PRINT(  );
    lex_print_path_option( XGC_ENVELOP_FILE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nget the capacity of the envelop\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XGC_GET_CAPACITY, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %senvelop_size.json ",
              all_args[XLC_LOGGING_CONF], all_args[XLC_LIB_INFO_LOG], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %senvelop_file.xf \n\n",
              all_args[XGC_GET_CAPACITY], all_args[XGC_ENVELOP_FILE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "printf '\\nstore the length of the input file in a variable\\n'\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "capacity_block=$(cat %senvelop_size.json | grep byte_capacity | sed 's/^.*:.//' | tr -d '}' | tr -d ' ' )\n\n",
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\ncreate steganography block\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XMSB_MAKE_STEGANOGRAPHY_BLOCK, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %s ",
              all_args[XEC_ENCODING_CONF], all_args[XEC_COMPILED_PARAM], all_args[XEC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s 0 %s 301097 %s 35 %s %ssteganography_block.xf %s %senvelop_file.xf %s %splain_text.txt \n\n",
              all_args[XMSB_MAKE_STEGANOGRAPHY_BLOCK],
              all_args[XMSB_OFFSET], all_args[XMSB_LENGTH], all_args[XMSB_TAG], all_args[XMSB_EMBEDDED_FILE],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XMSB_ENVELOP_FILE], LEXER_EXAMPLES_DUMP_DIR,
              all_args[XMSB_SOURCE_FILE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "printf '\\nextract steganography block\\n'\n" );
    XLEX_PRINT(  );
    lex_print_scripts_command_prelude( XESB_EXTRACT_STEGANOGRAPHY_BLOCK, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s %s ",
              all_args[XDC_DECODING_CONF], all_args[XDC_COMPILED_PARAM], all_args[XDC_NO_PASSWORD] );
    XLEX_PRINT(  );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s %s %ssteganography_block.xf %s %sblock_file.xf \n\n",
              all_args[XESB_EXTRACT_STEGANOGRAPHY_BLOCK], all_args[XESB_EMBEDDED_FILE],
              LEXER_EXAMPLES_DUMP_DIR, all_args[XESB_BLOCK_FILE], LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );

    lex_print_scripts_which_dir(  );

}

void lexscripts_all( int command, int rnd, char *all_args[]
 )
{

    int rnd_ot;

    rnd_ot = 0;

    lex_print_scripts_prelude( command, all_args );

    if ( command == XDC_DECODING_CONF ) {
    } else if ( command == XEC_ENCODING_CONF ) {
    } else if ( command == XAC_ARITHMETIC_CONF ) {
    } else if ( command == XSC_SEQUENCE_CONF ) {
    } else if ( command == XPC_PERMUTATION_CONF ) {
    } else if ( command == XLC_LOGGING_CONF ) {
    } else if ( command == XDEP_DUMP_ENCODING_PARAM ) {
        lex_script_decode_encode( rnd, all_args );
    } else if ( command == XDE_DECODE_ENCODE ) {
        lex_script_decode_encode( rnd, all_args );
    } else if ( command == XMXCR_MINE_XMATRIX_COMP_RND ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XMXCO_MINE_XMATRIX_COMP_OT ) {
        rnd_ot = 1;
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XPXCR_PERMUTE_XMATRIX_COMP_RANDOM ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XDX_DECOMPRESS_XMATRIX ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XCXC_CHECK_XMATRIX_COMP ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XCX_CHECK_XMATRIX ) {
        lex_script_mine_xmatrix_comp( rnd, rnd_ot, all_args );
    } else if ( command == XMP_MAKE_POINT ) {
        lex_script_make_confidential_pseudo_random_number( rnd, all_args );
    } else if ( command == XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER ) {
        lex_script_make_confidential_pseudo_random_number( rnd, all_args );
    } else if ( command == XMSP_MAKE_START_POINT ) {
        lex_script_monomial_key_exchange( rnd, all_args );
    } else if ( command == XMMK_MAKE_MONOMIAL_KEY ) {
        lex_script_monomial_key_exchange( rnd, all_args );
    } else if ( command == XMBK_MAKE_BINOMIAL_KEY ) {
        lex_script_monomial_key_exchange( rnd, all_args );
    } else if ( command == XEMK_EXCHANGE_MONOMIAL_KEY ) {
        lex_script_monomial_key_exchange( rnd, all_args );
    } else if ( command == XMMK_MAKE_MONOVALENT_KEY ) {
        lex_script_polyvalent_key_exchange( rnd, all_args );
    } else if ( command == XEPK_EXCHANGE_POLYVALENT_KEY ) {
        lex_script_polyvalent_key_exchange( rnd, all_args );
    } else if ( command == XCMK_CHECK_MONOVALENT_KEY ) {
        lex_script_polyvalent_key_exchange( rnd, all_args );
    } else if ( command == XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY ) {
        lex_script_zkp_binomial_key( rnd, all_args );
    } else if ( command == XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE ) {
        lex_script_zkp_signature( rnd, all_args );
    } else if ( command == XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE ) {
        lex_script_zkp_certificate( rnd, all_args );
    } else if ( command == XMR_MAKE_RESPONSE ) {
        lex_script_zkp_binomial_key( rnd, all_args );
    } else if ( command == XMMP_MAKE_MONOMIAL_PROOF ) {
        lex_script_zkp_binomial_key( rnd, all_args );
    } else if ( command == XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE ) {
        lex_script_zkp_signature( rnd, all_args );
    } else if ( command == XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE ) {
        lex_script_zkp_certificate( rnd, all_args );
    } else if ( command == XCMP_CHECK_MONOMIAL_PROOF ) {
        lex_script_zkp_binomial_key( rnd, all_args );
    } else if ( command == XCMPSS_CHECK_MONOMIAL_PROOF_SYM_SIGNATURE ) {
        lex_script_zkp_signature( rnd, all_args );
    } else if ( command == XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE ) {
        lex_script_zkp_certificate( rnd, all_args );
    } else if ( command == XMSS_MAKE_SIGNATURE_SYMMETRIC ) {
        lex_script_sym_signature( rnd, all_args );
    } else if ( command == XMSA_MAKE_SIGNATURE_ASYMMETRIC ) {
        lex_script_asy_signature( rnd, all_args );
    } else if ( command == XMRS_MAKE_RING_SIGNATURE ) {
        lex_script_ring_signature( rnd, all_args );
    } else if ( command == XPRS_PERMUTE_RING_SIGNATURE ) {
        lex_script_ring_signature( rnd, all_args );
    } else if ( command == XMCS_MAKE_CERTIFICATE_SYMMETRIC ) {
        lex_script_sym_certificate( rnd, all_args );
    } else if ( command == XMCA_MAKE_CERTIFICATE_ASYMMETRIC ) {
        lex_script_asy_certificate( rnd, all_args );
    } else if ( command == XCSS_CHECK_SIGNATURE_SYMMETRIC ) {
        lex_script_sym_signature( rnd, all_args );
    } else if ( command == XCSA_CHECK_SIGNATURE_ASYMMETRIC ) {
        lex_script_asy_signature( rnd, all_args );
    } else if ( command == XCRS_CHECK_RING_SIGNATURE ) {
        lex_script_ring_signature( rnd, all_args );
    } else if ( command == XCCS_CHECK_CERTIFICATE_SYMMETRIC ) {
        lex_script_sym_certificate( rnd, all_args );
    } else if ( command == XCCA_CHECK_CERTIFICATE_ASYMMETRIC ) {
        lex_script_asy_certificate( rnd, all_args );
    } else if ( command == XMH_MAKE_HASH ) {
        lex_script_hash( rnd, all_args );
    } else if ( command == XMC_MAKE_CHECKSUM ) {
        lex_script_checksum( rnd, all_args );
    } else if ( command == XCC_CHECK_CHECKSUM ) {
        lex_script_checksum( rnd, all_args );
    } else if ( command == XCH_CHECK_HASH ) {
        lex_script_hash( rnd, all_args );
    } else if ( command == XCHTMK_CONVERT_HASH_TO_MONOMIAL_KEY ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCHTP_CONVERT_HASH_TO_POINT ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCBKTSP_CONVERT_BINOMIAL_KEY_TO_START_POINT ) {
        lex_script_monomial_key_exchange( rnd, all_args );
    } else if ( command == XCSPTP_CONVERT_START_POINT_TO_POINT ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCPTSP_CONVERT_POINT_TO_START_POINT ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY ) {
        lex_script_sym_certificate( rnd, all_args );
    } else if ( command == XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY ) {
        lex_script_asy_certificate( rnd, all_args );
    } else if ( command == XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE ) {
        lex_script_conversions( rnd, all_args );
    } else if ( command == XSS_SPLIT_SYMMETRIC ) {
        lex_script_split( rnd, all_args );
    } else if ( command == XEA_ENCRYPT_ASYMMETRIC ) {
        lex_script_encrypt_asymmetric( rnd, all_args );
    } else if ( command == XES_ENCRYPT_SYMMETRIC ) {
        lex_script_encrypt_symmetric( rnd, all_args );
    } else if ( command == XJS_JOIN_SYMMETRIC ) {
        lex_script_split( rnd, all_args );
    } else if ( command == XDA_DECIPHER_ASYMMETRIC ) {
        lex_script_encrypt_asymmetric( rnd, all_args );
    } else if ( command == XDS_DECIPHER_SYMMETRIC ) {
        lex_script_encrypt_symmetric( rnd, all_args );
    } else if ( command == XCCB_CHECK_COMPLETE_BLOCK ) {
        lex_script_make_block( rnd, all_args );
    } else if ( command == XMB_MAKE_BLOCK ) {
        lex_script_make_block( rnd, all_args );
    } else if ( command == XCB_COMBINE_BLOCKS ) {
        lex_script_make_block( rnd, all_args );
    } else if ( command == XSHFB_STRIP_HEADER_FROM_BLOCK ) {
        lex_script_make_block( rnd, all_args );
    } else if ( command == XPH_PRINT_HEADER ) {
        lex_script_print_header( rnd, all_args );
    } else if ( command == XPLI_PRINT_LIB_INFO ) {
        lex_script_print_lib_info( rnd, all_args );
    } else if ( command == XGC_GET_CAPACITY ) {
        lex_script_make_steganography_block( rnd, all_args );
    } else if ( command == XMSB_MAKE_STEGANOGRAPHY_BLOCK ) {
        lex_script_make_steganography_block( rnd, all_args );
    } else if ( command == XESB_EXTRACT_STEGANOGRAPHY_BLOCK ) {
        lex_script_make_steganography_block( rnd, all_args );
    } else if ( command == XMSR_MAKE_STEGANOGRAPHY_RAW ) {
        lex_script_make_steganography_raw( rnd, all_args );
    } else if ( command == XESR_EXTRACT_STEGANOGRAPHY_RAW ) {
        lex_script_make_steganography_raw( rnd, all_args );
    }

}

